home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / memory / xms200je / xarrtest.cpp < prev    next >
C/C++ Source or Header  |  1993-11-22  |  7KB  |  257 lines
  1. //--------------------------------------------------------------------------
  2. //
  3. //      XARRTEST.CPP: test program for XMS array class.
  4. //      Copyright (c) J.English 1993.
  5. //      Author's address: je@unix.brighton.ac.uk
  6. //
  7. //      Permission is granted to use copy and distribute the
  8. //      information contained in this file provided that this
  9. //      copyright notice is retained intact and that any software
  10. //      or other document incorporating this file or parts thereof
  11. //      makes the source code for the library of which this file
  12. //      is a part freely available.
  13. //
  14. //--------------------------------------------------------------------------
  15. //
  16. //      Revision history:
  17. //      2.0     Nov 1993        Initial coding
  18. //
  19. //--------------------------------------------------------------------------
  20.  
  21. #include <stdio.h>
  22. #include <dos.h>
  23. #include "doserror.h"
  24. #include "xmsarray.h"
  25. #include "xms.h"
  26.  
  27.  
  28. //--------------------------------------------------------------------------
  29. //
  30. //      Global data.
  31. //
  32. DOSerror e;                     // prevent critical errors and control-breaks
  33. XMSarray<char>* arrs [100];     // array of pointers to XMS arrays
  34. int narrs = 0;                  // number of arrays
  35.  
  36.  
  37. //--------------------------------------------------------------------------
  38. //
  39. //      Function prototypes.
  40. //
  41. char menu ();                   // display menu & get user's choice
  42. void XMSstats ();               // 1. XMS statistics
  43. void arraysizes ();             // 2. Array sizes
  44. void allocate ();               // 3. Allocate array
  45. void deallocate ();             // 4. Deallocate array
  46. void copy ();                   // 5. Copy array
  47.  
  48. //--------------------------------------------------------------------------
  49. //
  50. //      Main program.
  51. //
  52. //      A menu of choices is displayed, allowing the user to exercise
  53. //      each of the XMS array functions available.
  54. //
  55. void main ()
  56. {
  57.     XMSstats();
  58.  
  59.     char choice;
  60.     for (;;)
  61.     {
  62.         choice = menu ();
  63.         if (choice == 'X')
  64.             break;
  65.  
  66.         switch (choice)
  67.         {
  68.             case '1':
  69.                 XMSstats ();
  70.                 break;
  71.             case '2':
  72.                 arraysizes ();
  73.                 break;
  74.             case '3':
  75.                 allocate ();
  76.                 break;
  77.             case '4':
  78.                 deallocate ();
  79.                 break;
  80.             case '5':
  81.                 copy ();
  82.                 break;
  83.         }
  84.     }
  85.     for (int i = 0; i < narrs; i++)
  86.         delete arrs[i];
  87. }
  88.  
  89. //--------------------------------------------------------------------------
  90. //
  91. //      Display menu and get user choice.
  92. //
  93. //      The choice must be a line containing a single character from 1 to 5
  94. //      (or X for exit).
  95. //
  96. char menu ()
  97. {
  98.     printf ("\nChoose desired operation:\n"
  99.             "  1) XMS statistics\n"
  100.             "  2) Array sizes\n"
  101.             "  3) Allocate array\n"
  102.             "  4) Deallocate array\n"
  103.             "  5) Copy array\n"
  104.             "  X) Exit program\n");
  105.     char buff [80];
  106.     for (;;)
  107.     {
  108.         printf ("Enter your choice: ");
  109.         fgets (buff, 80, stdin);
  110.         if ((buff[0] == 'x' || buff[0] == 'X') && buff[1] == '\n')
  111.             return 'X';
  112.         if (buff[0] < '1' || buff[0] > '5' || buff[1] != '\n')
  113.             printf ("Invalid choice!\a\n");
  114.         else
  115.             break;
  116.     }
  117.     printf ("\n");
  118.     return buff[0];
  119. }
  120.  
  121.  
  122. //--------------------------------------------------------------------------
  123. //
  124. //      Display XMS statistics.
  125. //
  126. void XMSstats ()
  127. {
  128.     printf ("XMS available: %ld bytes\nLargest block: %ld bytes\n",
  129.             XMS::available(), XMS::largest());
  130. }
  131.  
  132.  
  133. //--------------------------------------------------------------------------
  134. //
  135. //      Display array sizes.
  136. //
  137. void arraysizes ()
  138. {
  139.     int flag = 0;
  140.     for (int i = 0; i < narrs; i++)
  141.     {   if (arrs[i] != 0)
  142.         {   printf ("Array %d: size = %ld\n", i+1, arrs[i]->size());
  143.             flag = 1;
  144.         }
  145.     }
  146.     if (flag == 0)
  147.         printf ("No arrays allocated!\n");
  148. }
  149.  
  150. //--------------------------------------------------------------------------
  151. //
  152. //      Allocate array.
  153. //
  154. //      Attempt to allocate a new array of a specified size and report the
  155. //      result.
  156. //
  157. void allocate ()
  158. {
  159.     printf ("Enter array size: ");
  160.     long size;
  161.     scanf ("%ld", &size);
  162.     while (getchar() != '\n')
  163.         continue;
  164.     arrs [narrs++] = new XMSarray<char> (size);
  165.     printf ("Array %d: ", narrs);
  166.     printf ("requested %ld items, granted %ld items.\n",
  167.             size, arrs[narrs-1]->size());
  168.     if (!arrs[narrs-1]->valid())
  169.         delete arrs[--narrs];
  170. }
  171.  
  172.  
  173. //--------------------------------------------------------------------------
  174. //
  175. //      Deallocate array.
  176. //
  177. //      Attempt to deallocate an existing array and report the result.
  178. //
  179. void deallocate ()
  180. {
  181.     printf ("Enter array number: ");
  182.     int b;
  183.     scanf ("%d", &b); b--;
  184.     while (getchar() != '\n')
  185.         continue;
  186.     if (b < 0 || b >= narrs || arrs[b] == 0)
  187.         printf ("No such array!\n");
  188.     else
  189.     {   delete arrs[b];
  190.         arrs[b] = 0;
  191.         printf ("Array %d deallocated.\n", b+1);
  192.     }
  193. }
  194.  
  195. //--------------------------------------------------------------------------
  196. //
  197. //      Copy to/from XMS.
  198. //
  199. //      Prompts for an array number.  An array of random numbers is created
  200. //      in conventional memory, copied to the specified XMS array, copied
  201. //      back to conventional memory, and finally compared with the original
  202. //      array.
  203. //
  204. void copy ()
  205. {
  206.     printf ("Enter array number: ");
  207.     int b;
  208.     scanf ("%d", &b); b--;
  209.     while (getchar() != '\n')
  210.         continue;
  211.     if (b < 0 || b >= narrs || arrs[b] == 0)
  212.     {   printf ("No such array!\n");
  213.         return;
  214.     }
  215.  
  216.     const chunksize = 16384;
  217.     int size = (arrs[b]->size() > chunksize ? chunksize : arrs[b]->size());
  218.     int chunks = arrs[b]->size() / chunksize + 1;
  219.     char* x = new char [size];
  220.     char* y = new char [size];
  221.     if (x == 0 || y == 0)
  222.     {   printf ("Not enough real memory!\n");
  223.         return;
  224.     }
  225.  
  226.     randomize ();
  227.     printf ("Copying will be done in %d chunks of %d bytes each...\n",
  228.             chunks, size);
  229.     int fail;
  230.     for (long i = 0; i < chunks; i++)
  231.     {   int j;
  232.         fail = 0;
  233.         printf ("Chunk %ld: ", i + 1);
  234.         for (j = 0; j < size && i * size + j < arrs[b]->size(); j++)
  235.             x[j] = random (255);
  236.         printf ("writing... ");
  237.         for (j = 0; j < size && i * size + j < arrs[b]->size(); j++)
  238.             arrs[b]->at(i * size + j) = x[j];
  239.         printf ("reading... ");
  240.         for (j = 0; j < size && i * size + j < arrs[b]->size(); j++)
  241.             y[j] = arrs[b]->at(i * size + j);
  242.         printf ("verifying... ");
  243.         for (j = 0; j < size && i * size + j < arrs[b]->size(); j++)
  244.             if (x[j] != y[j])
  245.             {   printf ("error at offset %ld.\n", i * size + j);
  246.                 fail = 1;
  247.                 break;
  248.             }
  249.         if (!fail)
  250.             printf ("OK.\n");
  251.     }
  252.     if (!fail)
  253.         printf ("Copy test successful.\n");
  254.     delete x;
  255.     delete y;
  256. }
  257.